const express = require('express');
const path = require('path');
const cors = require('cors');
const multer = require('multer');
const { v4: uuidv4 } = require('uuid');
const jwt = require('jsonwebtoken');
const bcrypt = require('bcryptjs');
const fs = require('fs');
const session = require('express-session');
const { generateCaptcha } = require('./src/utils/captcha');
require('dotenv').config();

const app = express();
const port = process.env.PORT || 3000;

// 中间件配置
app.use(cors());
app.use(express.json());
app.use(express.static(path.join(__dirname, 'public')));
app.use('/uploads', express.static(path.join(__dirname, 'public/uploads')));
app.use(session({
    secret: process.env.SESSION_SECRET || 'your-secret-key',
    resave: false,
    saveUninitialized: true,
    cookie: { secure: false } // 开发环境设置为false，生产环境应该设置为true
}));

// JWT密钥
if (!process.env.JWT_SECRET) {
    throw new Error('JWT_SECRET environment variable is not set');
}
const JWT_SECRET = process.env.JWT_SECRET;

// 配置文件上传
const storage = multer.diskStorage({
    destination: function (req, file, cb) {
        const uploadDir = path.join(__dirname, 'public/uploads/avatars');
        if (!fs.existsSync(uploadDir)) {
            fs.mkdirSync(uploadDir, { recursive: true });
        }
        cb(null, uploadDir);
    },
    filename: function (req, file, cb) {
        const uniqueSuffix = Date.now() + '-' + Math.round(Math.random() * 1E9);
        cb(null, uniqueSuffix + path.extname(file.originalname));
    }
});

const upload = multer({
    storage: storage,
    limits: {
        fileSize: 5 * 1024 * 1024, // 限制文件大小为5MB
        files: 1 // 限制只能上传1个文件
    },
    fileFilter: function (req, file, cb) {
        // 只允许上传图片文件
        if (!file.originalname.match(/\.(jpg|jpeg|png|gif)$/)) {
            return cb(new Error('只允许上传图片文件！'), false);
        }
        cb(null, true);
    }
});

// 确保上传目录存在
const uploadsDir = path.join(__dirname, 'public/uploads/videos');
if (!fs.existsSync(uploadsDir)) {
    fs.mkdirSync(uploadsDir, { recursive: true });
}

// 视频上传配置
const videoUpload = multer({
    storage: multer.diskStorage({
        destination: (req, file, cb) => {
            cb(null, uploadsDir);
        },
        filename: (req, file, cb) => {
            const uniqueSuffix = Date.now() + '-' + Math.round(Math.random() * 1E9);
            cb(null, uniqueSuffix + path.extname(file.originalname));
        }
    }),
    limits: {
        fileSize: 500 * 1024 * 1024 // 500MB
    },
    fileFilter: (req, file, cb) => {
        const allowedTypes = ['video/mp4', 'video/webm', 'video/quicktime'];
        if (allowedTypes.includes(file.mimetype)) {
            cb(null, true);
        } else {
            cb(new Error('不支持的文件类型'));
        }
    }
});

// 验证token中间件
const authenticateToken = (req, res, next) => {
    const authHeader = req.headers['authorization'];
    const token = authHeader && authHeader.split(' ')[1];

    if (!token) {
        return res.status(401).json({ error: '未提供认证令牌' });
    }

    try {
        // 检查token是否存在于tokens.json中
        const tokensData = JSON.parse(fs.readFileSync(path.join(__dirname, 'data/tokens.json'), 'utf8'));
        const tokenData = tokensData.tokens.find(t => t.token === token);
        
        if (!tokenData) {
            return res.status(401).json({ error: '无效的认证令牌' });
        }

        // 检查token是否过期
        if (new Date(tokenData.expiresAt) < new Date()) {
            // 删除过期的token
            tokensData.tokens = tokensData.tokens.filter(t => t.token !== token);
            fs.writeFileSync(path.join(__dirname, 'data/tokens.json'), JSON.stringify(tokensData, null, 2));
            return res.status(401).json({ error: '认证令牌已过期' });
        }

        // 验证token
        jwt.verify(token, JWT_SECRET, (err, user) => {
            if (err) {
                return res.status(403).json({ error: '无效的认证令牌' });
            }
            req.user = user;
            next();
        });
    } catch (error) {
        console.error('认证错误:', error);
        res.status(500).json({ error: '认证失败，请稍后重试' });
    }
};

// 路由配置
app.get('/', (req, res) => {
    res.sendFile(path.join(__dirname, 'views', 'index.html'));
});

app.get('/videos', (req, res) => {
    res.sendFile(path.join(__dirname, 'views', 'videos.html'));
});

app.get('/video/:id', (req, res) => {
    res.sendFile(path.join(__dirname, 'views', 'video.html'));
});

app.get('/upload', (req, res) => {
    res.sendFile(path.join(__dirname, 'views', 'upload.html'));
});

app.get('/profile', (req, res) => {
    res.sendFile(path.join(__dirname, 'views', 'profile.html'));
});

// 验证码路由
app.get('/api/captcha', (req, res) => {
    const captcha = generateCaptcha();
    req.session.captcha = captcha.text.toLowerCase(); // 存储验证码文本（不区分大小写）
    res.type('svg');
    res.status(200).send(captcha.data);
});

// 用户认证相关路由
app.post('/api/auth/register', upload.single('avatar'), async (req, res) => {
    try {
        const { nickname, phone, email, password, captcha } = req.body;
        
        // 验证图形验证码
        if (captcha !== req.session.captcha) {
            return res.status(400).json({ error: '验证码错误' });
        }

        // 检查用户是否已存在
        const users = JSON.parse(fs.readFileSync(path.join(__dirname, 'data/users.json'), 'utf8'));
        if (users.users.some(user => user.email === email || user.phone === phone)) {
            return res.status(400).json({ error: '邮箱或手机号已被注册' });
        }

        // 密码加密
        const salt = await bcrypt.genSalt(10);
        const hashedPassword = await bcrypt.hash(password, salt);
        console.log('注册时生成的加密密码:', hashedPassword);

        // 创建新用户
        const newUser = {
            id: uuidv4(),
            nickname,
            phone,
            email,
            password: hashedPassword,
            avatar: req.file ? `/uploads/avatars/${req.file.filename}` : '/images/default-avatar.png',
            createTime: new Date().toISOString(),
            status: 'active'
        };

        users.users.push(newUser);
        fs.writeFileSync(path.join(__dirname, 'data/users.json'), JSON.stringify(users, null, 2));

        res.status(201).json({ message: '注册成功' });
    } catch (error) {
        console.error('注册错误:', error);
        res.status(500).json({ error: '注册失败' });
    }
});

// 登录路由
app.post('/api/auth/login', async (req, res) => {
    const { email, password } = req.body;
    
    try {
        // 先尝试在管理员中查找
        const adminsData = JSON.parse(fs.readFileSync(path.join(__dirname, 'data/admins.json'), 'utf8'));
        const admin = adminsData.admins.find(a => a.email === email);
        
        if (admin) {
            console.log('找到管理员账户:', admin.email);
            console.log('输入的密码:', password);
            console.log('存储的加密密码:', admin.password);
            
            // 验证管理员密码
            const isValidPassword = await bcrypt.compare(password, admin.password);
            console.log('密码验证结果:', isValidPassword);
            
            if (!isValidPassword) {
                console.log('管理员密码错误:', email);
                return res.status(401).json({ error: '密码错误' });
            }

            // 确保头像路径正确
            let avatarPath = admin.avatar || '/images/default-avatar.png';
            if (avatarPath && avatarPath.startsWith('/uploads/') && !avatarPath.startsWith('/uploads/avatars/')) {
                // 如果是旧路径格式，修正为新路径格式
                const filename = avatarPath.split('/').pop();
                avatarPath = `/uploads/avatars/${filename}`;
            }

            // 生成管理员JWT token
            const token = jwt.sign(
                { 
                    id: admin.id,
                    email: admin.email,
                    nickname: admin.nickname,
                    role: 'admin'
                },
                JWT_SECRET,
                { expiresIn: '24h' }
            );

            // 保存token到tokens.json
            const tokensData = JSON.parse(fs.readFileSync(path.join(__dirname, 'data/tokens.json'), 'utf8'));
            tokensData.tokens.push({
                userId: admin.id,
                token: token,
                role: 'admin',
                createdAt: new Date().toISOString(),
                expiresAt: new Date(Date.now() + 24 * 60 * 60 * 1000).toISOString()
            });
            fs.writeFileSync(path.join(__dirname, 'data/tokens.json'), JSON.stringify(tokensData, null, 2));

            return res.json({
                token,
                user: {
                    id: admin.id,
                    nickname: admin.nickname,
                    email: admin.email,
                    avatar: avatarPath,
                    role: 'admin'
                }
            });
        }

        // 如果不是管理员，查找普通用户
        const usersData = JSON.parse(fs.readFileSync(path.join(__dirname, 'data/users.json'), 'utf8'));
        const user = usersData.users.find(u => u.email === email);
        
        if (!user) {
            console.log('用户不存在:', email);
            return res.status(401).json({ error: '用户不存在' });
        }

        console.log('找到用户账户:', user.email);
        console.log('输入的密码:', password);
        console.log('存储的加密密码:', user.password);
        
        // 验证用户密码
        const isValidPassword = await bcrypt.compare(password, user.password);
        console.log('密码验证结果:', isValidPassword);
        
        if (!isValidPassword) {
            console.log('用户密码错误:', email);
            return res.status(401).json({ error: '密码错误' });
        }

        // 确保头像路径正确
        let avatarPath = user.avatar || '/images/default-avatar.png';
        if (avatarPath && avatarPath.startsWith('/uploads/') && !avatarPath.startsWith('/uploads/avatars/')) {
            // 如果是旧路径格式，修正为新路径格式
            const filename = avatarPath.split('/').pop();
            avatarPath = `/uploads/avatars/${filename}`;
            
            // 更新用户数据中的头像路径
            user.avatar = avatarPath;
            fs.writeFileSync(path.join(__dirname, 'data/users.json'), JSON.stringify(usersData, null, 2));
        }

        // 生成用户JWT token
        const token = jwt.sign(
            { 
                id: user.id,
                email: user.email,
                nickname: user.nickname,
                role: 'user'
            },
            JWT_SECRET,
            { expiresIn: '24h' }
        );

        // 保存token到tokens.json
        const tokensData = JSON.parse(fs.readFileSync(path.join(__dirname, 'data/tokens.json'), 'utf8'));
        tokensData.tokens.push({
            userId: user.id,
            token: token,
            role: 'user',
            createdAt: new Date().toISOString(),
            expiresAt: new Date(Date.now() + 24 * 60 * 60 * 1000).toISOString()
        });
        fs.writeFileSync(path.join(__dirname, 'data/tokens.json'), JSON.stringify(tokensData, null, 2));

        res.json({
            token,
            user: {
                id: user.id,
                nickname: user.nickname,
                email: user.email,
                avatar: avatarPath,
                role: 'user'
            }
        });
    } catch (error) {
        console.error('登录错误:', error);
        res.status(500).json({ error: '登录失败，请稍后重试' });
    }
});

// 登出路由
app.post('/api/auth/logout', authenticateToken, (req, res) => {
    try {
        const token = req.headers['authorization']?.split(' ')[1];
        if (!token) {
            return res.status(401).json({ error: '未提供认证令牌' });
        }

        // 从tokens.json中删除token
        const tokensData = JSON.parse(fs.readFileSync(path.join(__dirname, 'data/tokens.json'), 'utf8'));
        tokensData.tokens = tokensData.tokens.filter(t => t.token !== token);
        fs.writeFileSync(path.join(__dirname, 'data/tokens.json'), JSON.stringify(tokensData, null, 2));

        res.json({ message: '登出成功' });
    } catch (error) {
        console.error('登出错误:', error);
        res.status(500).json({ error: '登出失败，请稍后重试' });
    }
});

// 获取用户信息
app.get('/api/auth/user', authenticateToken, (req, res) => {
    try {
        const users = JSON.parse(fs.readFileSync(path.join(__dirname, 'data/users.json'), 'utf8'));
        const user = users.users.find(u => u.id === req.user.id);
        
        if (!user) {
            return res.status(404).json({ error: '用户不存在' });
        }

        // 确保头像路径正确
        let avatarPath = user.avatar || '/images/default-avatar.png';
        if (avatarPath && avatarPath.startsWith('/uploads/') && !avatarPath.startsWith('/uploads/avatars/')) {
            // 如果是旧路径格式，修正为新路径格式
            const filename = avatarPath.split('/').pop();
            avatarPath = `/uploads/avatars/${filename}`;
            
            // 更新用户数据中的头像路径
            user.avatar = avatarPath;
            fs.writeFileSync(path.join(__dirname, 'data/users.json'), JSON.stringify(users, null, 2));
        }

        res.json({
            id: user.id,
            nickname: user.nickname,
            email: user.email,
            avatar: avatarPath
        });
    } catch (error) {
        console.error('获取用户信息错误:', error);
        res.status(500).json({ error: '获取用户信息失败' });
    }
});

// 视频上传路由
app.post('/api/videos/upload', authenticateToken, videoUpload.single('video'), async (req, res) => {
    try {
        console.log('收到视频上传请求');
        console.log('请求头:', req.headers);
        console.log('请求体:', req.body);
        console.log('文件:', req.file);

        if (!req.file) {
            console.log('没有收到文件');
            return res.status(400).json({ error: '请选择视频文件' });
        }

        console.log('文件信息:', {
            filename: req.file.filename,
            path: req.file.path,
            size: req.file.size,
            mimetype: req.file.mimetype
        });

        const videoData = {
            id: Date.now().toString(),
            title: req.body.title || '未命名视频',
            description: req.body.description || '',
            uploaderId: req.user.id,
            url: `/uploads/videos/${req.file.filename}`,
            createTime: new Date().toISOString(),
            status: 'active',
            views: 0,
            likes: 0,
            comments: 0
        };

        console.log('准备保存的视频数据:', videoData);

        // 读取现有视频数据
        let videos = [];
        try {
            console.log('读取现有视频数据');
            const videosData = await fs.promises.readFile(path.join(__dirname, 'data/videos.json'), 'utf8');
            videos = JSON.parse(videosData).videos || [];
            console.log('现有视频数量:', videos.length);
        } catch (error) {
            console.log('创建新的视频数据文件');
            await fs.promises.writeFile(
                path.join(__dirname, 'data/videos.json'),
                JSON.stringify({ videos: [] }, null, 2)
            );
        }

        // 添加新视频
        videos.push(videoData);
        console.log('添加新视频到列表');

        // 保存更新后的视频数据
        console.log('保存更新后的视频数据');
        await fs.promises.writeFile(
            path.join(__dirname, 'data/videos.json'),
            JSON.stringify({ videos }, null, 2)
        );

        console.log('视频上传成功');
        res.json({
            message: '视频上传成功',
            video: videoData
        });
    } catch (error) {
        console.error('视频上传错误:', error);
        res.status(500).json({ error: '视频上传失败: ' + error.message });
    }
});

// 获取视频列表
app.get('/api/videos', async (req, res) => {
    try {
        const page = parseInt(req.query.page) || 1;
        const pageSize = parseInt(req.query.pageSize) || 12;
        const search = req.query.search || '';
        const sort = req.query.sort || 'latest';
        
        // 读取视频数据
        const videosData = await fs.promises.readFile(path.join(__dirname, 'data/videos.json'), 'utf8');
        let { videos } = JSON.parse(videosData);
        
        // 搜索过滤
        if (search) {
            const searchLower = search.toLowerCase();
            videos = videos.filter(video => 
                video.title.toLowerCase().includes(searchLower) ||
                video.description.toLowerCase().includes(searchLower)
            );
        }
        
        // 排序
        switch (sort) {
            case 'popular':
                videos.sort((a, b) => b.views - a.views);
                break;
            case 'latest':
            default:
                videos.sort((a, b) => new Date(b.createTime) - new Date(a.createTime));
        }
        
        // 分页处理
        const startIndex = (page - 1) * pageSize;
        const endIndex = startIndex + pageSize;
        const paginatedVideos = videos.slice(startIndex, endIndex);
        
        // 获取用户信息
        const usersData = await fs.promises.readFile(path.join(__dirname, 'data/users.json'), 'utf8');
        const { users } = JSON.parse(usersData);
        
        // 添加用户信息到视频
        const videosWithUser = paginatedVideos.map(video => {
            const user = users.find(u => u.id === video.uploaderId);
            return {
                ...video,
                author: user ? {
                    id: user.id,
                    nickname: user.nickname,
                    avatar: user.avatar
                } : null
            };
        });
        
        res.json({
            videos: videosWithUser,
            total: videos.length,
            page,
            pageSize
        });
    } catch (error) {
        console.error('获取视频列表错误:', error);
        res.status(500).json({ error: '获取视频列表失败' });
    }
});

// 获取单个视频信息
app.get('/api/videos/:id', async (req, res) => {
    try {
        const videoId = req.params.id;
        console.log('获取视频信息，ID:', videoId);
        
        const videosData = await fs.promises.readFile(path.join(__dirname, 'data/videos.json'), 'utf8');
        const { videos } = JSON.parse(videosData);
        const video = videos.find(v => v.id === videoId);

        if (!video) {
            console.log('视频不存在:', videoId);
            return res.status(404).json({ error: '视频不存在' });
        }

        console.log('找到视频:', video);

        // 获取作者信息
        const usersData = await fs.promises.readFile(path.join(__dirname, 'data/users.json'), 'utf8');
        const { users } = JSON.parse(usersData);
        const author = users.find(u => u.id === video.uploaderId);
        if (author) {
            video.author = {
                id: author.id,
                nickname: author.nickname,
                avatar: author.avatar
            };
        }

        // 确保视频 URL 是完整的
        if (video.url) {
            if (!video.url.startsWith('http')) {
                video.url = video.url.startsWith('/') ? video.url : `/${video.url}`;
            }
            console.log('处理后的视频URL:', video.url);
        } else {
            console.error('视频URL不存在');
            return res.status(404).json({ error: '视频URL不存在' });
        }

        res.json(video);
    } catch (error) {
        console.error('获取视频信息失败:', error);
        res.status(500).json({ error: '获取视频信息失败' });
    }
});

// 更新视频播放次数
app.post('/api/videos/:id/view', authenticateToken, async (req, res) => {
    try {
        const videoId = req.params.id;
        const videosData = await fs.promises.readFile(path.join(__dirname, 'data/videos.json'), 'utf8');
        const videos = JSON.parse(videosData);
        const videoIndex = videos.findIndex(v => v.id === videoId);

        if (videoIndex === -1) {
            return res.status(404).json({ error: '视频不存在' });
        }

        videos[videoIndex].views += 1;
        await fs.promises.writeFile(
            path.join(__dirname, 'data/videos.json'),
            JSON.stringify(videos, null, 2)
        );

        res.json({ views: videos[videoIndex].views });
    } catch (error) {
        console.error('更新播放次数失败:', error);
        res.status(500).json({ error: '更新播放次数失败' });
    }
});

// 获取视频评论
app.get('/api/videos/:id/comments', async (req, res) => {
    try {
        const videoId = req.params.id;
        console.log('获取视频评论，视频ID:', videoId);
        
        // 读取评论数据
        let comments = [];
        try {
            const commentsData = await fs.promises.readFile(path.join(__dirname, 'data/comments.json'), 'utf8');
            comments = JSON.parse(commentsData).comments || [];
            console.log('读取到的评论数据:', comments);
        } catch (error) {
            console.log('评论文件不存在或为空，使用空数组');
        }

        // 过滤视频评论
        const videoComments = comments.filter(c => c.videoId === videoId && c.status !== 'deleted');
        console.log('过滤后的视频评论:', videoComments);

        // 获取用户信息
        const usersData = await fs.promises.readFile(path.join(__dirname, 'data/users.json'), 'utf8');
        const { users } = JSON.parse(usersData);

        // 添加用户信息到评论
        const commentsWithUserInfo = videoComments.map(comment => {
            const user = users.find(u => u.id === comment.userId);
            return {
                ...comment,
                author: user ? {
                    id: user.id,
                    nickname: user.nickname,
                    avatar: user.avatar
                } : null
            };
        });

        console.log('返回的评论数据:', commentsWithUserInfo);
        res.json(commentsWithUserInfo);
    } catch (error) {
        console.error('获取评论失败:', error);
        res.status(500).json({ error: '获取评论失败' });
    }
});

// 发表评论
app.post('/api/videos/:id/comments', authenticateToken, async (req, res) => {
    try {
        const videoId = req.params.id;
        const { content } = req.body;
        const userId = req.user.id;

        console.log('收到评论请求:', {
            videoId,
            userId,
            content
        });

        if (!content) {
            return res.status(400).json({ error: '评论内容不能为空' });
        }

        // 验证视频是否存在
        const videosData = await fs.promises.readFile(path.join(__dirname, 'data/videos.json'), 'utf8');
        const { videos } = JSON.parse(videosData);
        const video = videos.find(v => v.id === videoId);
        
        if (!video) {
            console.log('视频不存在:', videoId);
            return res.status(404).json({ error: '视频不存在' });
        }

        // 读取现有评论数据
        let comments = [];
        try {
            const commentsData = await fs.promises.readFile(path.join(__dirname, 'data/comments.json'), 'utf8');
            comments = JSON.parse(commentsData).comments || [];
            console.log('现有评论数量:', comments.length);
        } catch (error) {
            console.log('评论文件不存在，创建新文件');
        }

        // 创建新评论
        const newComment = {
            id: Date.now().toString(),
            videoId,
            userId,
            content,
            timestamp: new Date().toISOString(),
            status: 'active',
            likes: 0
        };

        console.log('创建新评论:', newComment);

        // 添加新评论
        comments.push(newComment);

        // 保存更新后的评论数据
        await fs.promises.writeFile(
            path.join(__dirname, 'data/comments.json'),
            JSON.stringify({ comments }, null, 2)
        );

        // 更新视频评论数
        const videoIndex = videos.findIndex(v => v.id === videoId);
        if (videoIndex !== -1) {
            videos[videoIndex].comments = (videos[videoIndex].comments || 0) + 1;
            await fs.promises.writeFile(
                path.join(__dirname, 'data/videos.json'),
                JSON.stringify({ videos }, null, 2)
            );
        }

        // 获取用户信息
        const usersData = await fs.promises.readFile(path.join(__dirname, 'data/users.json'), 'utf8');
        const { users } = JSON.parse(usersData);
        const user = users.find(u => u.id === userId);

        // 返回带有用户信息的评论
        const commentWithUser = {
            ...newComment,
            author: user ? {
                id: user.id,
                nickname: user.nickname,
                avatar: user.avatar
            } : null
        };

        console.log('返回评论数据:', commentWithUser);
        res.json(commentWithUser);
    } catch (error) {
        console.error('发表评论失败:', error);
        res.status(500).json({ error: '发表评论失败' });
    }
});

// 删除视频
app.delete('/api/videos/:id', authenticateToken, async (req, res) => {
    try {
        console.log('收到删除视频请求，视频ID:', req.params.id, '用户ID:', req.user.id);
        
        const videosData = await fs.promises.readFile(path.join(__dirname, 'data/videos.json'), 'utf8');
        const parsedData = JSON.parse(videosData);
        const videos = parsedData.videos || [];
        const videoIndex = videos.findIndex(v => v.id === req.params.id);

        if (videoIndex === -1) {
            console.log('视频不存在:', req.params.id);
            return res.status(404).json({ error: '视频不存在' });
        }

        // 检查权限
        const video = videos[videoIndex];
        if (video.uploaderId !== req.user.id && req.user.role !== 'admin') {
            console.log('没有权限删除视频:', req.params.id, '上传者ID:', video.uploaderId, '请求用户ID:', req.user.id);
            return res.status(403).json({ error: '没有权限删除此视频' });
        }

        // 删除视频文件
        try {
            const videoPath = path.join(__dirname, 'public', video.url.replace(/^\//, ''));
            console.log('删除视频文件:', videoPath);
            
            // 检查文件是否存在
            if (fs.existsSync(videoPath)) {
                await fs.promises.unlink(videoPath);
                console.log('视频文件已删除');
            } else {
                console.warn('视频文件不存在:', videoPath);
            }
            
            // 如果有缩略图，也删除
            if (video.thumbnail) {
                const thumbnailPath = path.join(__dirname, 'public', video.thumbnail.replace(/^\//, ''));
                if (fs.existsSync(thumbnailPath)) {
                    await fs.promises.unlink(thumbnailPath);
                    console.log('缩略图已删除:', thumbnailPath);
                }
            }
        } catch (fileError) {
            console.error('删除视频文件失败:', fileError);
            // 继续执行，即使文件删除失败也要从数据库中移除记录
        }

        // 从数组中移除视频
        videos.splice(videoIndex, 1);

        // 保存更新后的视频数据
        await fs.promises.writeFile(
            path.join(__dirname, 'data/videos.json'), 
            JSON.stringify({ videos }, null, 2)
        );
        console.log('视频记录已从数据库删除');

        res.json({ message: '视频删除成功' });
    } catch (error) {
        console.error('删除视频错误:', error);
        res.status(500).json({ error: '删除视频失败: ' + error.message });
    }
});

// 管理员相关路由
app.get('/api/admin/videos/pending', authenticateToken, (req, res) => {
    // TODO: 获取待审核视频列表
    res.json({ message: '获取待审核视频列表接口待实现' });
});

app.post('/api/admin/videos/review', authenticateToken, (req, res) => {
    // TODO: 视频审核
    res.json({ message: '视频审核接口待实现' });
});

// 评论相关路由
app.post('/api/videos/:videoId/comments', authenticateToken, async (req, res) => {
    try {
        const { content } = req.body;
        const videoId = req.params.videoId;

        // 验证视频是否存在
        const videosData = await fs.promises.readFile(path.join(__dirname, 'data/videos.json'), 'utf8');
        const { videos } = JSON.parse(videosData);
        const video = videos.find(v => v.id === videoId);
        
        if (!video) {
            return res.status(404).json({ error: '视频不存在' });
        }

        // 读取现有评论数据
        let comments = [];
        try {
            const commentsData = await fs.promises.readFile(path.join(__dirname, 'data/comments.json'), 'utf8');
            comments = JSON.parse(commentsData).comments || [];
        } catch (error) {
            // 如果文件不存在，使用空数组
        }

        // 创建新评论
        const comment = {
            id: Date.now().toString(),
            videoId,
            userId: req.user.id,
            content,
            createTime: new Date().toISOString(),
            status: 'active'
        };

        // 添加新评论
        comments.push(comment);

        // 保存更新后的评论数据
        await fs.promises.writeFile(
            path.join(__dirname, 'data/comments.json'),
            JSON.stringify({ comments }, null, 2)
        );

        res.json({
            message: '评论发布成功',
            comment
        });
    } catch (error) {
        console.error('发布评论错误:', error);
        res.status(500).json({ error: '发布评论失败' });
    }
});

// 获取视频评论列表
app.get('/api/videos/:videoId/comments', async (req, res) => {
    try {
        const videoId = req.params.videoId;
        const page = parseInt(req.query.page) || 1;
        const pageSize = parseInt(req.query.pageSize) || 10;

        // 读取评论数据
        const commentsData = await fs.promises.readFile(path.join(__dirname, 'data/comments.json'), 'utf8');
        const { comments } = JSON.parse(commentsData);

        // 过滤视频评论并按时间倒序排序
        const videoComments = comments
            .filter(c => c.videoId === videoId && c.status === 'active')
            .sort((a, b) => new Date(b.createTime) - new Date(a.createTime));

        // 分页处理
        const startIndex = (page - 1) * pageSize;
        const endIndex = startIndex + pageSize;
        const paginatedComments = videoComments.slice(startIndex, endIndex);

        // 获取用户信息
        const usersData = await fs.promises.readFile(path.join(__dirname, 'data/users.json'), 'utf8');
        const { users } = JSON.parse(usersData);

        // 添加用户信息到评论
        const commentsWithUser = paginatedComments.map(comment => {
            const user = users.find(u => u.id === comment.userId);
            return {
                ...comment,
                user: user ? {
                    id: user.id,
                    nickname: user.nickname,
                    avatar: user.avatar
                } : null
            };
        });

        res.json({
            comments: commentsWithUser,
            total: videoComments.length,
            page,
            pageSize
        });
    } catch (error) {
        console.error('获取评论列表错误:', error);
        res.status(500).json({ error: '获取评论列表失败' });
    }
});

// 删除评论
app.delete('/api/comments/:id', authenticateToken, async (req, res) => {
    try {
        const commentId = req.params.id;
        console.log('删除评论，评论ID:', commentId);

        // 读取评论数据
        const commentsData = await fs.promises.readFile(path.join(__dirname, 'data/comments.json'), 'utf8');
        const { comments } = JSON.parse(commentsData);
        const commentIndex = comments.findIndex(c => c.id === commentId);

        if (commentIndex === -1) {
            console.log('评论不存在:', commentId);
            return res.status(404).json({ error: '评论不存在' });
        }

        const comment = comments[commentIndex];

        // 检查权限（只有评论作者和管理员可以删除）
        if (comment.userId !== req.user.id && req.user.role !== 'admin') {
            console.log('没有权限删除评论:', commentId);
            return res.status(403).json({ error: '没有权限删除此评论' });
        }

        // 软删除评论（更新状态）
        comments[commentIndex].status = 'deleted';

        // 保存更新后的评论数据
        await fs.promises.writeFile(
            path.join(__dirname, 'data/comments.json'),
            JSON.stringify({ comments }, null, 2)
        );

        console.log('评论删除成功:', commentId);
        res.json({ message: '评论删除成功' });
    } catch (error) {
        console.error('删除评论错误:', error);
        res.status(500).json({ error: '删除评论失败' });
    }
});

// 获取视频缩略图
app.get('/api/videos/:id/thumbnail', async (req, res) => {
    try {
        const videoId = req.params.id;
        console.log('获取视频缩略图，ID:', videoId);
        
        // 1. 查找视频信息
        const videosData = await fs.promises.readFile(path.join(__dirname, 'data/videos.json'), 'utf8');
        const { videos } = JSON.parse(videosData);
        const video = videos.find(v => v.id === videoId);

        if (!video) {
            console.log('视频不存在:', videoId);
            return res.status(404).sendFile(path.join(__dirname, 'public/images/default-thumbnail.svg'));
        }

        // 2. 如果视频有缩略图，重定向到缩略图
        if (video.thumbnail) {
            let thumbnailPath = video.thumbnail;
            if (!thumbnailPath.startsWith('/')) {
                thumbnailPath = `/uploads/thumbnails/${thumbnailPath}`;
            }
            return res.redirect(thumbnailPath);
        }

        // 3. 没有缩略图，返回默认图片
        res.sendFile(path.join(__dirname, 'public/images/default-thumbnail.svg'));
        
    } catch (error) {
        console.error('获取视频缩略图失败:', error);
        res.status(500).sendFile(path.join(__dirname, 'public/images/default-thumbnail.svg'));
    }
});

// 用户密码更新
app.put('/api/users/password', authenticateToken, async (req, res) => {
    try {
        const { currentPassword, newPassword, confirmPassword } = req.body;
        const userId = req.user.id;
        
        console.log('收到密码更新请求，用户ID:', userId);
        
        // 验证请求参数
        if (!currentPassword || !newPassword) {
            return res.status(400).json({ error: '当前密码和新密码都是必需的' });
        }
        
        if (newPassword.length < 6) {
            return res.status(400).json({ error: '新密码长度不能少于6个字符' });
        }
        
        if (confirmPassword && newPassword !== confirmPassword) {
            return res.status(400).json({ error: '两次输入的新密码不一致' });
        }
        
        // 读取用户数据
        const usersData = JSON.parse(fs.readFileSync(path.join(__dirname, 'data/users.json'), 'utf8'));
        const userIndex = usersData.users.findIndex(u => u.id === userId);
        
        if (userIndex === -1) {
            console.log('用户不存在:', userId);
            return res.status(404).json({ error: '用户不存在' });
        }
        
        const user = usersData.users[userIndex];
        
        // 验证当前密码
        const isCurrentPasswordValid = await bcrypt.compare(currentPassword, user.password);
        if (!isCurrentPasswordValid) {
            console.log('当前密码验证失败，用户ID:', userId);
            return res.status(400).json({ error: '当前密码不正确' });
        }
        
        // 加密新密码
        const hashedNewPassword = await bcrypt.hash(newPassword, 10);
        
        // 更新用户密码
        usersData.users[userIndex].password = hashedNewPassword;
        fs.writeFileSync(path.join(__dirname, 'data/users.json'), JSON.stringify(usersData, null, 2));
        
        // 删除所有该用户的token（登出所有设备）
        const tokensData = JSON.parse(fs.readFileSync(path.join(__dirname, 'data/tokens.json'), 'utf8'));
        tokensData.tokens = tokensData.tokens.filter(t => t.userId !== userId);
        fs.writeFileSync(path.join(__dirname, 'data/tokens.json'), JSON.stringify(tokensData, null, 2));
        
        console.log('密码更新成功，用户ID:', userId);
        res.json({ success: true, message: '密码更新成功，请重新登录' });
    } catch (error) {
        console.error('密码更新错误:', error);
        res.status(500).json({ error: '密码更新失败，请稍后重试' });
    }
});

// 错误处理中间件
app.use((err, req, res, next) => {
    console.error(err.stack);
    res.status(500).json({
        error: '服务器内部错误',
        message: err.message
    });
});

// 启动服务器
app.listen(port, () => {
    console.log(`服务器运行在 http://localhost:${port}`);
}); 